#include <iostream>
#include "dsexceptions.h"
#include <algorithm>
using namespace std;
/**
 * @brief 
 * 要求是能够编写设计抽象类，其他类能够从此派生；
 * 我的思路是从共有，私有，以及指针各个方面找出BinarySearchTree，Avltree以及SplayTree
 * 的公共的部分，然后将公共部分编写到BinaryTree中。
 *  
 */
template <typename Comparable>
class BinaryTree
{
public:
/**
 * @brief Construct a new Binary Tree object
 * 构造函数编写
 */
    BinaryTree(): 
    {}
    BinaryTree(const BinaryTree & rhs )
    {
    }

    BinaryTree(const BinaryTree && rhs) root{rhs.root}
    {

    }
    /**
     * @brief Destroy the Binary Tree object
     * 析构函数
     */
    virtual ~BinaryTree()
    {
        makeEmpty();
    }
    /**
     * @brief 
     * 
     * @param rhs 
     * @return BinaryTree& 
     */

    BinaryTree & operator =(const BinaryTree & rhs)
    {
        BinaryTree copy = rhs.root;
        std::swap(*this,copy);
        return *this;
    }

    BinaryTree & operator = (const BinaryTree && rhs)
    {
        std swap(root,rhs.root);
        return *this;
    }

    /**
     * @brief 
     * 以下是他们的共有的成员函数，包括了找最大值最小值、检查某元素是否在树中
     * 检查树是否为空，清楚树中所有元素，打印所有元素，插入，删除
     *  
     */
    virtual const Comparable & findMin() const
    {}
    virtual const Comparable & findMax() const
    {}
    virtual bool contains(const Comparable & x)
    {}
    
    virtual bool isEmpty()
    {}
    virtual void printTree() const
    {}
    virtual void makeEmpty()
    {}
    virtual void insert(const Comparable & x)
    {}
    virtual void insert(const Comparable && x)
    {}
    virtual void remove(const Comparable & x)
    {}
private:

    binarynode *root;

    virtual void printTree(binarynode *t) const
    {}

    virtual binarynode * clone(binarynode *t) const
    {}

    
};


template <typename Comparable>
class binarynode
{
    Comparable x;
    BinaryNode *left;
    BinaryNode *right;

};

